Kasimir Blust - Portfolio

Micro-Optimization
Performance of Unity methods

In my spare time I like to think of ways to program better in Unity. Most of the time that thought goes way beyond what you will ever need in a practical developement cycle.

In the last few days I was curious how fast (or slow) those methods we call all the time (and maybe shouldn't) actually are. This thought came from a post that said GetComponent was as bad as GameObject.Find(). I couldn't believe that so I started testing. What I eventually tested was:

this.GetComponent<Test>()
this.AddStuff<float>(t)
this.AddSomething(t)
this.gameObject.transform
Time.deltaTime
this.gameobject
Input.GetKeyDown(Keycode.A)
GameObject.Find(this.name)

As I suspected both method vary widely.
My test consisted of 5 GameObjects in the scene where one had one child. Thes test ran for 1300 frames with a starting offset of 200 frames (so that the startup will not affect the times). Each frame the tests were executed 20.000 times and timed with Stopwatch().

I tested this on a Mac Mini (Sierra) with a 2,3 GHz Intel Core i7 and 8GB of memory. For graphics it has an Intel HD Graphics 4000 (1536 MB) integrated.

GameObject.Find(this.name)
- Min: 2,25 ms
- Avg: 2,402 ms
- Max: 4,207 ms
GetComponent<Test>()
- Min: 10,244 ms
- Avg: 11,809 ms
- Max: 24,809 ms

So GameObject.Find is definately worse :)
I did not expect to have a difference so high with only 6 GameObjects in the scene.

Because GameObject.Find is so slow I excluded it from the rest of the results.
The rest for me is way more interesting:

This shows that clearly you should try not to use GetComponent very often. With that said, even if you would call GetComponent 1.000 times, on average, you will loose only about 0,7 ms.

Given that you would need 20 thousand calls to have an effect of around a half a millisecond in most cases, I think you can ignore the cost of calls to transform or even GetKeyDown. If you have thousands of GameObjects that call Input.GetKeyDown you probably have bigger problems.

Generally there are always bottelnecks that will probably weigh way harder than GetComponent.
For your own verification, at the bottom is the code of the complete test. Here is the excel file with all the raw data down below so you can make your own fancy graphs :)

I thought this was it. Simple tests but they showed nothing really new.
A few weeks later someone asked me if they could easily check 200 vectors in a loop. I knew they were making an app that had to support at least the Ipad Mini 1 or equal. So I thought: Let's test it!
And it got interesting...

As you can see GameObject.Find() is even worse with an average caculation time on Ipad Mini 1 of 68 ms! That means in one millisecond you can only search about 145 times and thats it! But more importantly: Look at the IPhone 7's results in this.Getcomponent():

They are even a little bit higher than GameObject.Find().

Here are the other images I took leaving out GameObject.Find and then this.Getcomponent().

using System.Collections.Generic;
using UnityEngine;

namespace Testing
{

	public class Test : MonoBehaviour
	{

		public int TestCount = 20000;
		private readonly List<FinishedTest> _tests = new List<FinishedTest>();

		public int Steps = 1300;
		public int StepOffset = 200;
		private int _stepCounter = 1500;

		private void Awake()
		{
			// Add test items to a list for data storage
			_tests.Add(new FinishedTest("this.GetComponent<Test>()"));
			_tests.Add(new FinishedTest("this.AddStuff<float>(t)"));
			_tests.Add(new FinishedTest("this.AddSomething(t)"));
			_tests.Add(new FinishedTest("this.gameObject.transform"));
			_tests.Add(new FinishedTest("Time.deltaTime"));
			_tests.Add(new FinishedTest("this.gameobject"));
			_tests.Add(new FinishedTest("Input.GetKeyDown(Keycode.A)"));
			_tests.Add(new FinishedTest("GameObject.Find(this.name)"));

			// Preapre testing environment
			_stepCounter = Steps + StepOffset;
		}

		private void Update()
		{
			// Count the steps backwards
			_stepCounter--;

			if (_stepCounter <= 0)
			{
				// Test is finished
				string[] output = new string[_tests.Count];
				for (int i = 0; i < _tests.Count; i++)
				{
					output[i] = _tests[i].ToString();
				}

				Debug.Log(string.Join("\n", output));
				this.enabled = false;
			}

			// Do nothing for a few first frames => StepOffset
			if (_stepCounter > Steps)
				return;

			// Create Stopwatch and testID that increments for every test => List _tests
			int testID = 0;
			System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();


			// Testing this.GetComponent
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				Test test = this.GetComponent<Test>();
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing Template method call
			float t = 5f;
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				this.DoTemplateStuff<float>(t);
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing simple method call
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				this.DoSomething(t);
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing this.gameobject.transform
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				Transform trans = this.gameObject.transform;
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing Time.deltaTime
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				float time = Time.deltaTime;
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing this.gameobject
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				GameObject go = this.gameObject;
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing Get Key Down
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				bool keystroke = Input.GetKeyDown(KeyCode.A);
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;


			// Testing GameObject Find
			watch.Reset();
			watch.Start();
			// Test starting
			for (int i = 0; i < TestCount; i++)
			{
				GameObject keystroke = GameObject.Find(this.name);
			}

			watch.Stop();
			_tests[testID].AddFrameTime(watch.Elapsed.TotalMilliseconds);
			testID++;
		}

		/// <summary>
		/// Tests a simple templated method call.
		/// </summary>
		/// <param name="test"></param>
		/// <typeparam name="T"></typeparam>
		private void DoTemplateStuff<T>(T test)
		{
			T test2 = test;
		}

		/// <summary>
		/// Tests a simple method call.
		/// </summary>
		/// <param name="test"></param>
		/// <typeparam name="T"></typeparam>
		private void DoSomething(float test)
		{
			float test2 = test;
		}

		/// <summary>
		/// Class to hold test data.
		/// Generated average, minum and maximum with each new entry.
		/// Stores only double values for better precision
		/// </summary>
		private class FinishedTest
		{
			private readonly string _title;
			private double _avg, _total, _min = 50d, _max, _current;
			private int _count;

			public FinishedTest(string title)
			{
				this._title = title;
			}

			/// <summary>
			/// Call this to add the current test values
			/// </summary>
			/// <param name="time"></param>
			public void AddFrameTime(double time)
			{
				_count++;
				this._total += time;
				this._current = time;
				if (time < _min)
					this._min = time;
				if (time > this._max)
					this._max = time;
				this._avg = this._total / (double) this._count;
			}

			public override string ToString()
			{
				// Values can be exported directly into Excel
				return this._title + ";" + this._avg.ToString("0.000").Replace('.', ',') + ";" +
				       this._min.ToString("0.000").Replace('.', ',') + ";" + this._max.ToString("0.000").Replace('.', ',') + ";" +
				       this._current.ToString("0.000").Replace('.', ',');
			}
		}
	}
}